Memory management systems typically keep track of memory objects after they are created and delete those objects when they are no longer needed so that the memory may be freed for re-use. These systems, which are sometimes also known as garbage collectors, often work by maintaining a reference count that is associated with each memory object, for example when that object is created or allocated in memory. The reference count is incremented when a thread (or process or other entity) accesses or otherwise references that memory object. The reference count is decremented when the thread deletes or de-references the memory object. When the reference count reaches zero, the memory object is assumed to no longer be in use and the memory manager may free the memory for re-use (although not required to) and thus reduce the possibility of running out of memory.
Additionally, computing systems often have multiple processing cores over which a given workload may be distributed to increase computational throughput. Each core may have an associated memory cache that operates at a higher speed than the main memory. When multiple threads are executing on different processor cores and accessing, or sharing, a common memory object, the reference count for that object will typically need to be transferred from one cache to another, which may result in increased latencies and reduced processing efficiency. As the computing system scales upwards in size, to greater numbers of cores and threads executing in parallel, the memory management problems associated with reference count swapping from cache to cache may result in decreased performance that impedes scalability.
Although the following Detailed Description will proceed with reference being made to illustrative embodiments, many alternatives, modifications, and variations thereof will be apparent to those skilled in the art.